{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pytorch Neural Network Modules\n",
    "==============================\n",
    "\n",
    "Pytorch uses the `torch.nn.Module` class to represent a neural network.\n",
    "\n",
    "A `Module` is just a **callable** function that can be:\n",
    "\n",
    " * **Parameterized** by trainable `Parameter` tensors that the module can list out.\n",
    " * **Composed** out of children `Module`s that contribute parameters.\n",
    " * **Saved and Loaded** by listing named parameters and other attribute buffers.\n",
    "\n",
    "Pytorch comes with several built-in elementary network modules, like a generic single-layer `Linear` network, or a generic `Sequential` composition of other networks, but of course you can write your own `Module` subclasses by just defining `Parameter` attributes and using them to implement a computation.\n",
    "\n",
    "To see how every `Module` manages its own portion of responsibilities of all the network duties above, we first look at how to use the built-in `Linear` and `Sequential` modules."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using torch.nn.Linear as a Neural Network\n",
    "=========================================\n",
    "\n",
    "The linear layer is not just a good starting example: it is the fundmental workhorse of all neural networks, so as simple as it is, it is worth examining carefully.\n",
    "\n",
    "`torch.nn.Linear` implements the function `y = Ax + b`, which takes m-dimensional input `x` and produces n-dimensional output `y`, by multiplying by the n &times; m matrix `A` (whose specific values are called the `weight`) and adding n-dimensional vector `b` (whose values are called the `bias`).  We can make a Linear network with 3d input and 2d output just like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear(in_features=3, out_features=2, bias=True)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "net = torch.nn.Linear(3, 2)\n",
    "print(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like any Module, our little network can be run as a function.  As expected, when we give it 3-d vector as input, we get a 2-d vector as output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.4530,  0.6047]], grad_fn=<AddmmBackward0>)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net(torch.tensor([[1.0, 0.0, 0.0]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Batchwise processing is assumed in pytorch networks.** Notice the double nesting in the vector data above.  This is needed because our `Linear`  network is slightly different from a plain matrix-vector multiplication. By convention, pytorch `Module`s are set up to process data in batches, so to give it a single 3-d vector, instead of passing just a vector, we have passed it a singleton batch containing one vector.\n",
    "\n",
    "We can instead send in several inputs - here we provide four vectors as inputs.  The network then gives us four vectors as outputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-0.4530,  0.6047],\n",
       "        [-0.3436, -0.0084],\n",
       "        [-0.0957,  0.2989],\n",
       "        [-0.1118,  0.0888]], grad_fn=<AddmmBackward0>)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_batch = torch.tensor([\n",
    "    [1.0, 0. , 0. ],\n",
    "    [0. , 1.0, 0. ],\n",
    "    [0. , 0. , 1.0],\n",
    "    [0. , 0. , 0. ],\n",
    "])\n",
    "net(x_batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Parameters are randomly initializated by default.** What strange function is this Linear layer computing?  By default pytorch has initialized the weights and bias randomly.  We can look at these random parameters directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight is Parameter containing:\n",
      "tensor([[-0.3413, -0.2319,  0.0160],\n",
      "        [ 0.5159, -0.0972,  0.2101]], requires_grad=True)\n",
      "bias is Parameter containing:\n",
      "tensor([-0.1118,  0.0888], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "print('weight is', net.weight)\n",
    "print('bias is', net.bias)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "1. Set the `bias` of the network to the zero vector.\n",
    "2. Examine the numerical results of `net(x_batch)`.  Do the answers match the parameters as you would expect?\n",
    "\n",
    "**Hint**: although `x.zero_()` or `x[:] = 0.0` can zero a vector in place, since the network parameters are all `requires_grad=True`, you will need to put things in a `with torch.no_grad()` block to temporarily disable autograd before changing the values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Set the bias of the network to the zero vector.\n",
    "# TODO: Compare the numerical results of net(x_batch) to the parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Parameters are set up for autograd and optimization, and can be listed out.**  Above you can see that both the weight and the bias are trainable parameters, because they both have the `Parameter` type.  The tensors also both marked as `requires_grad=True`, which means they are marked to participate in autograd and optimization for training.\n",
    "\n",
    "These are the only two trainable parameters of the network.  To check this, we can list all parameters by name, using `net.named_parameters()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight = Parameter containing:\n",
      "tensor([[-0.3413, -0.2319,  0.0160],\n",
      "        [ 0.5159, -0.0972,  0.2101]], requires_grad=True)\n",
      "\n",
      "bias = Parameter containing:\n",
      "tensor([-0.1118,  0.0888], requires_grad=True)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for name, param in net.named_parameters():\n",
    "    print(f'{name} = {param}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A Module can be saved by saving its state_dict.**   `net.state_dict()` is similar to `net.named_parameters()` but it returns a detached reference to the data (that is, `requires_grad=False`) so the data can be saved directly.  Also, for more complicated modules, `state_dict()` may include other non-trainable attributes that are needed to save the network's state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight: torch.FloatTensor(2, 3)\n",
      "bias: torch.FloatTensor(2,)\n"
     ]
    }
   ],
   "source": [
    "for k, v in net.state_dict().items():\n",
    "    print(f'{k}: {v.type()}{tuple(v.shape)}')\n",
    "\n",
    "import os\n",
    "os.makedirs('checkpoints', exist_ok=True)\n",
    "torch.save(net.state_dict(), 'checkpoints/linear.pth')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**load_state_dict() can be used to reload a saved Module.**  Pytorch also comes with convenient `torch.save` and `torch.load` functions for saving state dicts to files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Then later, to remember the state\n",
    "net.load_state_dict(torch.load('checkpoints/linear.pth'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise:\n",
    "\n",
    "1. Define a linear layer **without** bias, as in `net2 = torch.nn.Linear(3, 2, bias=False)`.\n",
    "2. Load the previously saved state dict in 'checkpoints/linear.pth' into this new layer, ignoring the saved bias.\n",
    "\n",
    "Loading trained parameters from one network into a different network with a changed architecture is a more common trick than you might imagine.  It is the core technique of *transfer learning*.\n",
    "\n",
    "**Hint**: you can get pytorch to do this in a couple ways.  One way is to manually change the dictionary keys, in this case deleting the `bias` parameter from the state dict after loading it from the file and before passing it to `net2.load_state_dict`.  The other way is to try the `strict=False` option on load_state_dict, which will print a warning about the mismatch but proceed anyway.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: define net2 without bias.\n",
    "# TODO: load the previously saved state dict, ignoring the saved bias."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training Example: Optimizing a Linear Layer\n",
    "-------------------------------------------\n",
    "\n",
    "To train a network we need to come up with a score for how close we are to the goal.  This scalar number is called the **objective** or the **loss**.\n",
    "\n",
    "For example, suppose we would like this network to always output `[1, 1]` regardless of input.  Then a reasonable loss would be the mean squared distance to `[1, 1]`, computed like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss is 2.212045431137085\n"
     ]
    }
   ],
   "source": [
    "y_batch = net(x_batch)\n",
    "loss = ((y_batch - torch.tensor([[1.0, 1.0]])) ** 2).sum(1).mean()\n",
    "print(f'loss is {loss}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use autograd get gradients to see how small changes in every parameter would impact the loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight is Parameter containing:\n",
      "tensor([[-0.3413, -0.2319,  0.0160],\n",
      "        [ 0.5159, -0.0972,  0.2101]], requires_grad=True) and grad is:\n",
      "tensor([[-0.7265, -0.6718, -0.5479],\n",
      "        [-0.1976, -0.5042, -0.3506]])\n",
      "\n",
      "bias is Parameter containing:\n",
      "tensor([-0.1118,  0.0888], requires_grad=True) and grad is:\n",
      "tensor([-2.5021, -1.5080])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "loss.backward()\n",
    "print(f'weight is {net.weight} and grad is:\\n{net.weight.grad}\\n')\n",
    "print(f'bias is {net.bias} and grad is:\\n{net.bias.grad}\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Simple gradient descent can be done directly.**  To improve our layer, we can use simple gradient descent with a learning rate of 0.01.  That is, we can adjust each parameter by subtracting 0.01 times the gradient.  If we do this repeatedly, we should get closer to our objective.\n",
    "\n",
    "Any time we directly update the network parameters, we need to temporarily disable the autograd machinery using `with torch.no_grad()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight is Parameter containing:\n",
      "tensor([[7.5908e-06, 7.5909e-06, 7.5911e-06],\n",
      "        [1.4001e-05, 1.4001e-05, 1.4001e-05]], requires_grad=True)\n",
      "\n",
      "bias is Parameter containing:\n",
      "tensor([1.0000, 1.0000], requires_grad=True)\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "net = torch.nn.Linear(3, 2)\n",
    "log = []\n",
    "for _ in range(10000):\n",
    "    y_batch = net(x_batch)\n",
    "    loss = ((y_batch - torch.tensor([[1.0, 1.0]])) ** 2).sum(1).mean()\n",
    "    log.append(loss.item())\n",
    "    net.zero_grad()\n",
    "    loss.backward()\n",
    "    with torch.no_grad():\n",
    "        for p in net.parameters():\n",
    "            p[...] -= 0.01 * p.grad\n",
    "print(f'weight is {net.weight}\\n')\n",
    "print(f'bias is {net.bias}\\n')\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('iteration')\n",
    "plt.plot(log)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "1. Use `plt.yscale('log')` to plot the loss on a log scale.\n",
    "2. Look directly at `net.bias` and use subtraction to see how far it is from (1,1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Plot the evolution of the loss on a log scale.\n",
    "# TODO: Examine net.bias directly and compare to (1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voila, we have trained a simple neural network to our desired objective of outputting a constant ones vector.  After a few thousand updates, the weight has a near-zero matrix, and the bias becomes `[1.0, 1.0]`, as desired.\n",
    "\n",
    "**A realistic training loop would run on the GPU using bigger batches of randomized input and a prepackaged optimization algorithm.**\n",
    "\n",
    "Below we create a newly randomized `Linear` net instance, and train it on the GPU using the Adam optimizer fo 1000 iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weight is Parameter containing:\n",
      "tensor([[-6.5037e-09,  2.4067e-09, -1.6668e-08],\n",
      "        [-5.2088e-09,  2.3515e-09, -6.8763e-09]], device='cuda:0',\n",
      "       requires_grad=True)\n",
      "\n",
      "bias is Parameter containing:\n",
      "tensor([1.0000, 1.0000], device='cuda:0', requires_grad=True)\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7b603527f0>]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from torch.optim import Adam\n",
    "net = torch.nn.Linear(3, 2)\n",
    "optimizer = Adam(net.parameters(), lr=0.01)\n",
    "# Move the network, target value, and training inputs to the GPU\n",
    "net.cuda()\n",
    "target = torch.tensor([[1.0, 1.0]], device='cuda') \n",
    "log = []\n",
    "for _ in range(1000):\n",
    "    y_batch = net(torch.randn(100, 3, device='cuda'))\n",
    "    loss = ((y_batch - target) ** 2).sum(1).mean()\n",
    "    log.append(loss.item())\n",
    "    net.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "print(f'weight is {net.weight}\\n')\n",
    "print(f'bias is {net.bias}\\n')\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('iteration')\n",
    "plt.plot(log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "1. Again, use `plt.yscale('log')` to plot the loss on a log scale.\n",
    "2. Look directly at `net.bias` and use subtraction to see how far it is from (1,1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Plot the evolution of the loss on a log scale again.\n",
    "# TODO: Examine net.bias directly.  How does Adam doo?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>function toggle_code(){$('.rendered.selected div.input').toggle().find('textarea').focus();} $(toggle_code)</script>\n",
       "<a href=\"javascript:toggle_code()\">Toggle</a> the code for visualize_net."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This visulaization function is used for the next example\n",
    "\n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def visualize_net(net, classify_target):\n",
    "    fig, (ax1, ax2) = plt.subplots(1, 2)\n",
    "    grid = torch.stack([\n",
    "        torch.linspace(-2, 2, 100)[None, :].expand(100, 100),\n",
    "        torch.linspace(2, -2, 100)[:, None].expand(100, 100),\n",
    "    ])\n",
    "    x, y = grid\n",
    "    target = classify_target(x, y)\n",
    "    ax1.set_title('target')\n",
    "    ax1.imshow(target.float(), cmap='hot', extent=[-2,2,-2,2])\n",
    "    ax2.set_title('network output')\n",
    "    score = net(grid.permute(1, 2, 0).reshape(-1, 2).cuda()).softmax(1)\n",
    "    ax2.imshow(score[:,1].reshape(100, 100).detach().cpu(), cmap='hot', extent=[-2,2,-2,2])\n",
    "    plt.show()\n",
    "\n",
    "from IPython.display import HTML\n",
    "HTML('''<script>function toggle_code(){$('.rendered.selected div.input').toggle().find('textarea').focus();} $(toggle_code)</script>\n",
    "<a href=\"javascript:toggle_code()\">Toggle</a> the code for visualize_net.''')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using torch.nn.Sequential to Compose Networks\n",
    "---------------------------------------------\n",
    "\n",
    "Unlike `Linear`, most networks are made by composing many smaller networks.  The simplest way to do this is chain networks together end-to-end, connecting each output to the next input.  For example we can simply compose `Linear` layers.\n",
    "\n",
    "**Defining a Multilayer Perceptron.** Of course, to get something more interesting than another linear function, we need to do something nonlinear between the linear steps.  if we add a nonlinearity between each step (for example, if we clamp negative numbers to zero - an operation called `ReLU`), then we can get a **Multilayer Perceptron,** which is known to be a universal function approximator, i.e., a family of piecewise-linear functions that can approximate any function.\n",
    "\n",
    "\n",
    "Here is how we can express the network as a nested set of Sequentials."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential(\n",
      "  (layer1): Sequential(\n",
      "    (0): Linear(in_features=2, out_features=20, bias=True)\n",
      "    (1): ReLU()\n",
      "  )\n",
      "  (layer2): Sequential(\n",
      "    (0): Linear(in_features=20, out_features=20, bias=True)\n",
      "    (1): ReLU()\n",
      "  )\n",
      "  (layer3): Sequential(\n",
      "    (0): Linear(in_features=20, out_features=2, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "from collections import OrderedDict\n",
    "from torch.nn import Linear, ReLU, Sequential\n",
    "\n",
    "mlp = torch.nn.Sequential(OrderedDict([\n",
    "    ('layer1', Sequential(Linear(2, 20), ReLU())),\n",
    "    ('layer2', Sequential(Linear(20, 20), ReLU())),\n",
    "    ('layer3', Sequential(Linear(20, 2)))\n",
    "]))\n",
    "\n",
    "print(mlp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above, we have nested two levels of Sequentials.  In the outermost level, we have defined and named three layers.\n",
    "\n",
    "Then each layer is itself a Sequential that executes a parameterized `Linear` operation followed by a `ReLU` nonlinear clamping operation.  We have not bothered to name each of the innermost steps, so the Sequential just automatically numbers them.\n",
    "\n",
    "**Every submodule has a fully qualified name.** We can get a full recursive list of submodules by listing `net.named_modules()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The whole network is a Sequential\n",
      "layer1 is a Sequential\n",
      "layer1.0 is a Linear\n",
      "layer1.1 is a ReLU\n",
      "layer2 is a Sequential\n",
      "layer2.0 is a Linear\n",
      "layer2.1 is a ReLU\n",
      "layer3 is a Sequential\n",
      "layer3.0 is a Linear\n"
     ]
    }
   ],
   "source": [
    "for n, c in mlp.named_modules():\n",
    "    print(f'{n or \"The whole network\"} is a {type(c).__name__}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A module's parameters include all its child module parameters.** We can see this by listing all the parameters by name.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer1.0.weight has shape (20, 2)\n",
      "layer1.0.bias has shape (20,)\n",
      "layer2.0.weight has shape (20, 20)\n",
      "layer2.0.bias has shape (20,)\n",
      "layer3.0.weight has shape (2, 20)\n",
      "layer3.0.bias has shape (2,)\n"
     ]
    }
   ],
   "source": [
    "for name, param in mlp.named_parameters():\n",
    "    print(f'{name} has shape {tuple(param.shape)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are now six parameters: a weight and a bias for each of the three `Linear` layers.\n",
    "\n",
    "**Training a Clasifier.** This slightly more complicated network can now represent a more general class of functions. For example, we can use this architecture to learn to compute a classifier function.  \n",
    "\n",
    "Suppose we want to classify points on a plane as either above a sine-wave (class 1) or below a sine-wave (class 0). Here is the ordinary training loop to train our MLP to do it, using the Adam optimizer:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 0 accuracy: 0.46459999680519104\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 1 accuracy: 0.4667999744415283\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 3 accuracy: 0.6401999592781067\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 7 accuracy: 0.7739999890327454\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 15 accuracy: 0.781499981880188\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 31 accuracy: 0.8039000034332275\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 63 accuracy: 0.9238999485969543\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 127 accuracy: 0.9684999585151672\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 255 accuracy: 0.9878000020980835\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 511 accuracy: 0.984499990940094\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 1023 accuracy: 0.9902999997138977\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from torch.nn.functional import cross_entropy\n",
    "\n",
    "def classify_target(x, y):\n",
    "    return (y > (x * 3).sin()).long()\n",
    "\n",
    "mlp.cuda()\n",
    "optimizer = Adam(mlp.parameters(), lr=0.01)\n",
    "for iteration in range(1024):\n",
    "    in_batch = torch.randn(10000, 2, device='cuda')\n",
    "    target_batch = classify_target(in_batch[:,0], in_batch[:,1])\n",
    "    out_batch = mlp(in_batch)\n",
    "    loss = cross_entropy(out_batch, target_batch)\n",
    "    if iteration > 0:\n",
    "        mlp.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "    if iteration == 2 ** iteration.bit_length() - 1:\n",
    "        pred_batch = out_batch.max(1)[1]\n",
    "        accuracy = (pred_batch == target_batch).float().sum() / len(in_batch)\n",
    "        print(f'Iteration {iteration} accuracy: {accuracy}')\n",
    "        visualize_net(mlp, classify_target)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "1. Try another classification objective.  Try `(y > x**2).long()`.\n",
    "2. Try another one: try `(y.floor() == x.floor()).long()`.\n",
    "3. Make up another one to try.  Can you find a simple objective that the network has trouble matching?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: repeat the experiment with `(y > x**2).long()` as the classification objective.\n",
    "# TODO: use `(y.floor() == x.floor()).long()` as the objective.\n",
    "# TODO: find a simple objective that the network has trouble matching.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A network can be saved by saving its state_dict.**  Since the state_dict gathers together all the parameters of the submodules, we can save it all at once.  Note that since every parameter is given a fully-qualified name, if we wanted to load just a subset of the layers, we could do that by picking out keys of the dictionary and adjusting their names by hand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer1.0.weight: torch.float32(20, 2)\n",
      "layer1.0.bias: torch.float32(20,)\n",
      "layer2.0.weight: torch.float32(20, 20)\n",
      "layer2.0.bias: torch.float32(20,)\n",
      "layer3.0.weight: torch.float32(2, 20)\n",
      "layer3.0.bias: torch.float32(2,)\n"
     ]
    }
   ],
   "source": [
    "for k, v in mlp.state_dict().items():\n",
    "    print(f'{k}: {v.dtype}{tuple(v.shape)}')\n",
    "\n",
    "torch.save(mlp.state_dict(), 'checkpoints/mlp.pth')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining `forward` to Create Custom Networks\n",
    "--------------------------------\n",
    "\n",
    "Sometimes you will want to hook up network components in a more complicated way than just a sequential operation of predefined components.\n",
    "\n",
    "For example, [ResNet](https://arxiv.org/abs/1512.03385) is built on the observation that learning can work much better if, instead of learning an arbitrary linear operation, we learn perturbations of the identity.  I.e., have a layer learn to compute a small residual instead of the whole total answer.\n",
    "\n",
    "To apply the residual trick in our little three-layer network, we cannot just use an overall `Sequential`: instead we will define the operation by writing our own `forward` function.  It looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MyNetwork(\n",
      "  (layer1): Sequential(\n",
      "    (0): Linear(in_features=2, out_features=20, bias=True)\n",
      "    (1): ReLU()\n",
      "  )\n",
      "  (residual_layer2): Sequential(\n",
      "    (0): Linear(in_features=20, out_features=20, bias=True)\n",
      "    (1): ReLU()\n",
      "  )\n",
      "  (layer3): Linear(in_features=20, out_features=2, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "class MyNetwork(torch.nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.layer1 = Sequential(Linear(2, 20), ReLU())\n",
    "        self.residual_layer2 = Sequential(Linear(20, 20), ReLU())\n",
    "        self.layer3 = Linear(20, 2)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.layer1(x)\n",
    "        x = x + self.residual_layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        return x\n",
    "\n",
    "res_mlp = MyNetwork()\n",
    "print(res_mlp)\n",
    "\n",
    "# Exercise left to you: try training res_mlp just like we trained mlp above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training the network above can be done exactly the same way as training our previous `Sequential` mlp.  Try copying+pasting the training code and adapting it to this new network."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise:\n",
    "\n",
    "1. Write a training loop for `res_mlp`.\n",
    "2. Try various classification objectives.  How does it compare to mlp?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other `Module` tricks\n",
    "\n",
    " * **torch.nn.Parameter** wraps trainable parameters. In the `__init__()` method, you can define more tensors as parameters to be optimized, by wrapping parameter tensors with a `torch.nn.Parameter` before setting the attribute.  See the [pytorch Linear source code](https://github.com/pytorch/pytorch/blob/master/torch/nn/modules/linear.py#L74-L78) to see an example.  (In that code, the `in_features` and `out_features` attributes are just ordinary numbers that are not trainable, but `weight` and `bias` are wrapped in `Parameter` objects to mark them as trainable tensors.)\n",
    " * **module.training** allows special behavior during training. Some modules behave differently at training time than at inference time.  For example, a [Dropout](http://jmlr.org/papers/volume15/srivastava14a/srivastava14a.pdf) layer will drop half the channels and amplify the other half randomly during training, but at inference, for better performance, it will include all the channels. To support this sort of trick, there is a `module.train()` method to put a module (recursively) into training mode and a `module.eval()` to put it into inference mode.  The `module.training` boolean tells which mode is current.  See the [pytorch dropout source code](https://github.com/pytorch/pytorch/blob/master/torch/nn/modules/dropout.py#L24-L58) to see the `training` flag in use.\n",
    " * **buffers** can be learned without the optimizer.  Not every attribute of a module needs to be trainable by the optimizer.  Some attributes can be learned in a different way, for example, by observing and averaging statistics observed during training time.  The most famous example of this is the [Batchnorm](https://arxiv.org/abs/1502.03167) layer, which observes mean and variance during training, and accumulates statistics to enforces zero mean and unit variance.  See the pytorch [batchnorm module source code](https://github.com/pytorch/pytorch/blob/master/torch/nn/modules/batchnorm.py#L27-L55) for an example of using **buffers** which are not optimized by the optimizer.\n",
    " * **Predefined model architectures** are available; for example, `torchvision.models.resnet18(num_classes=100)` will create a ResNet-18 classifier model, configured to do a 100-way classification of images.  See [torchvision.models documentation](https://pytorch.org/docs/stable/torchvision/models.html) for the standard torchvision model zoo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [On to topic 5: Datasets and DataLoaders &rightarrow;](5-Pytorch-Dataloader.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
